'''
序列：存储多个值的连续空间 用索引来标识每个值 (字符串是不可变序列)
'''
# 切片 [开始（包含，默认从0）:结束（不包含，默认最后）:步长（默认1）]
s="helloworld"
s1 = s[0:5:2] # s[:5:2]
print(s1)
'''
序列的操作
'''
#相加
s1 = [1,2,3,4]
s2 = [5,6,7,8]
s3 = s1 + s2
print(s3)
# 操作符
s = 3
print('s是否在s1的元素中：',s in s1)
print('s是否不在s1的元素中：',s not in s1)
print('s1长度',len(s1))
print('s1最大值',max(s1))
print('s1最小值',min(s1))
print('s在s1的第一个出现的索引',s1.index(s))
print('s在s1中出现的个数',s1.count(s))


#----------------------------列表------------------------------------
'''
列表：可变序列
[] 定义，,分割
可以是任意数据类型
    创建方式： 1. [] 2.list()
    删除： del 列表名
'''
list1 = [1,2,3,3,'hasd',4.2]
list2 = list(range(5))

# del list2

# 遍历方式
# 直接遍历元素
for item in list2:
    pass
# 遍历索引
for index in (range(0,len(list2))):
    pass
# 遍历索引和元素 enumerate(list,start=x) 手动指定起始值
for index,item in enumerate(list2):
    pass

'''
列表操作
list.append(x) 末尾追加
list.insert(index,x) 指定位追加
list.clear() 清空元素
list.pop(index) 取出指定位并删除
list.remove(x) 删除指定元素
list.reverse() 反转
list.copy() 复制一个新列表 

列表排序
list.sort(key,reverse=false) key 排序规则 reverse是否降序 默认false 注：对原对象操作
或
内置函数sorted(list,key,reverse=false) 元素 排序规则 是否降序  注：会产生新对象

列表生成式
lst = [exp for item in range] exp相当于return 每个循环中的值
lst = [exp for item in range if condition]
'''
# 4行5列的2维列表
list = [ [j for j in range(5)] for i in range(4)] # 这里用的生成式，在第二层for把j作为元素返回，又在第一层中把j的数组作为元素返回
print(list)


#----------------------------元组------------------------------------
'''
元组：不可变序列
() 或 内置函数tuple()定义
内容只有一个也要加逗号
删除 del 元组名
'''
tuple1 = ('nihao',)
'''
遍历同列表遍历

元组生成式
tuple = [exp for item in range] exp返回的是一个生成器对象，需要tuple()方法 来转成元组，或调用__next()__方法来逐个获取元素
'''

'''
元组                列表
不可变序列          可变序列
可切片访问          可切片访问和修改
访问处理速度快      访问处理速度慢
可作为字典的键      不可作为字典键
'''

#----------------------------字典------------------------------------
'''
字典dict （hashmap）
可变键值对序列,key重复会覆盖前值
定义：
    1. {} k1:v1,k2:v2
    2. dict() zip对象转字典
    3. zip(l1,l2) l1:keys l2:values
'''
map1 = {1:'你好',2:'啊',3:'！'}

ls1 = [1,2,3,4,5] # 取决于key有多少个
ls2 = ['a','b','c','d','e']
mp1 = zip(ls1,ls2) # zip 对象 需要dict()转成字典
dict1 = dict(mp1)
print(mp1)
print(dict1)
print(dict(dog='狗',cat='猫'))
'''
字典的key是无序的，打印有序是3.6版本后处理了

'''
# 取值 d[k] 或 d.get(k) 前者会报错，后者可指定无值时返回的默认值
print(dict1[1])
print(dict1.get('key','没有'))
# 遍历 d.items() 返回kv元组 可分别取k v
for ele in dict1.items():
    print("ele",ele)
for k,v in dict1.items(): 
    print('k',k,'=>','v',v)
'''
字典操作方法
d.keys()            获取所有的key
d.values()          获取所有的value
d.prop(key,default) 存在key 取出并删除 否则返回default
d.popitem()         随机取出一个键值对并删除
d.clear()           清空
'''

'''
字典生成式
d = {key:value for item in range}
d = {key:value for key,value in zip(l1,l2)}
'''
import random
d1 = { i:random.randint(1,100) for i in range(4)}
d2 = { k:v for k,v in zip([1,2,3],['a','b','c'])}
print(d1,d2,sep='\n')


#----------------------------集合------------------------------------
'''
无序，不重复的序列 （set)
只能存不可变数据类型
{} 定义

创建
 1. {} ,分割 （注： {} 默认是空字典
 2. set(可迭代对象)
删除
 del
'''
set1 = {}
set2 = set()
set3 = set([1,2,3,4]) # 转成set
'''
操作符
 1. a & b 交集 ab共有
 2. a | b 并集 a+b
 3. a - b 差集 a独有
 4. a ^ b 补集 ab分别独有
'''
set1 = {10,20,30,40,50}
set2 = {20,33,45,83,40}
print("交集 ab共有",set1&set2)
print("并集 a+b",set1|set2)
print("差集 a独有",set1-set2)
print("补集 ab分别独有",set1^set2)
'''
操作方法
add(x) 没有则新增
remove(x) 删除 没有则报错
clear() 清空
'''
set1.remove(10)
set1.add(11)

# 遍历
for i in set1:
    pass
for i,item in enumerate(set1):
    pass

# 生成式 花括号
set3 = {i for i in range(1,10)}



'''
对比：
类型            序列类型            元素是否可重复          是否有序            定义符号            备注
------------------------------------------------------------------------------------------------------
列表list        可变                可重复                  有序                []              arraylist
元组tuple       不可变              可重复                  有序                ()              array，只有一个内容时也要, arr = (1,)
字典dict        可变                不可重复                无序                {key:value}     hashmap, d.items()返回的是kv元组
集合set         可变                不可重复                无序                {}              ,分割，hashset，只能存不可变数据类型
'''


'''
3.11 新特性

1. match 结构匹配
    match
        case ():  元组
        case []: 列表
        case {}: 字典
        case _: 其他
2. 字典合并运算符 |
'''
dict1 = {1:"ggb",2:"gggb"}
dict2 = {3:"ddd",4:"223",1:"ggb"}
print(dict1 | dict2)

'''
同步迭代 迭代dict用
'''
fruits = ['苹果','香蕉','桃子','西瓜','梨']
counts = [10,12,5,8]
for f,c in zip(fruits,counts): # 循环一个字典（map）
    match f,c:
        case '苹果',10:
            print("10个苹果",end="")
            pass
        case '香蕉',12:
            print("12个香蕉",end="")
            pass
        case '桃子',5:
            print("5个桃子",end="")
            pass
        case '西瓜',8:
            print("8个西瓜",end="")
            pass